const app = getApp()

Page({
  data: {
    isLoggedIn: false, // 默认为未登录状态
    userInfo: null,
    familyMembers: [],
    newMembers: []
  },

  onLoad: function() {
    // 页面加载时检查登录状态
    this.checkLoginStatus()
  },
  
  onShow: function() {
    // 页面显示时的逻辑
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        active: 1
      })
    }
    
    // 每次显示页面时刷新登录状态
    this.checkLoginStatus()
  },

  // 检查登录状态
  checkLoginStatus: function() {
    if (app.globalData.logged && app.globalData.userInfo) {
      this.setData({
        isLoggedIn: true,
        userInfo: app.globalData.userInfo
      })
      
      // 获取家庭成员数据
      this.getFamilyMembers()
    } else {
      // 尝试从本地存储获取用户信息
      const userInfo = wx.getStorageSync('userInfo')
      if (userInfo) {
        app.globalData.userInfo = userInfo
        app.globalData.logged = true
        this.setData({
          isLoggedIn: true,
          userInfo: userInfo
        })
        
        // 获取家庭成员数据
        this.getFamilyMembers()
      } else {
        this.setData({
          isLoggedIn: false,
          userInfo: null
        })
      }
    }
  },

  // 获取家庭成员数据
  getFamilyMembers: function() {
    wx.showLoading({
      title: '加载中...',
    })
    
    // 调用云函数获取家庭成员数据
    const db = wx.cloud.database()
    
    // 不要依赖userInfo中的_openid，而是直接查询当前用户创建的记录
    db.collection('familyMembers')
      .get()
      .then(res => {
        wx.hideLoading()
        if (res && res.data && res.data.length > 0) {
          this.setData({
            familyMembers: res.data
          })
        } else {
          // 如果没有数据，设置默认示例数据
          this.setData({
            familyMembers: [
              {
                id: 1,
                name: '爸爸',
                age: 45,
                height: 175,
                weight: 70,
                avoid: '海鲜',
                favor: '牛肉、土豆'
              },
              {
                id: 2,
                name: '妈妈',
                age: 42,
                height: 165,
                weight: 55,
                avoid: '辣椒',
                favor: '蔬菜、水果'
              }
            ]
          })
        }
      })
      .catch(err => {
        wx.hideLoading()
        console.error('获取家庭成员失败', err)
        
        // 如果没有数据，设置默认示例数据
        this.setData({
          familyMembers: [
            {
              id: 1,
              name: '爸爸',
              age: 45,
              height: 175,
              weight: 70,
              avoid: '海鲜',
              favor: '牛肉、土豆'
            },
            {
              id: 2,
              name: '妈妈',
              age: 42,
              height: 165,
              weight: 55,
              avoid: '辣椒',
              favor: '蔬菜、水果'
            }
          ]
        })
      })
  },

  // 登录
  login: function() {
    // 获取用户信息前，先获取授权
    wx.getUserProfile({
      desc: '用于完善家庭成员信息',
      success: (res) => {
        const userInfo = res.userInfo
        
        // 显示加载中提示
        wx.showLoading({
          title: '登录中...',
        })
        
        // 调用云函数登录，获取openid
        wx.cloud.callFunction({
          name: 'login',
          success: async (res) => {
            // 检查返回结果
            if (!res || !res.result || !res.result.openid) {
              wx.hideLoading()
              console.error('云函数返回结果异常', res)
              wx.showToast({
                title: '登录失败，请重试',
                icon: 'none'
              })
              return
            }
            
            // 获取openid
            const openid = res.result.openid
            
            // 准备用户数据 (不要手动设置_openid，云开发会自动设置)
            const userData = {
              avatarUrl: userInfo.avatarUrl,
              nickName: userInfo.nickName,
              gender: userInfo.gender,
              country: userInfo.country,
              province: userInfo.province,
              city: userInfo.city,
              createTime: new Date()
            }
            
            // 存储到数据库
            try {
              const db = wx.cloud.database()
              
              // 检查用户是否已存在
              const userCheck = await db.collection('users').where({
                _openid: openid
              }).get()
              
              if (userCheck.data.length === 0) {
                // 新用户，添加到数据库
                await db.collection('users').add({
                  data: userData
                })
              } else {
                // 更新用户信息 (不要更新_openid字段)
                await db.collection('users').where({
                  _openid: openid
                }).update({
                  data: {
                    avatarUrl: userInfo.avatarUrl,
                    nickName: userInfo.nickName,
                    updateTime: new Date()
                  }
                })
              }
              
              // 存储到全局数据和本地存储
              // 在本地存储中可以保留openid以便后续使用
              const userDataWithOpenid = {
                ...userData,
                _openid: openid
              }
              app.globalData.userInfo = userDataWithOpenid
              app.globalData.logged = true
              wx.setStorageSync('userInfo', userDataWithOpenid)
              
              // 更新页面状态
              this.setData({
                isLoggedIn: true,
                userInfo: userDataWithOpenid
              })
              
              // 获取家庭成员数据
              this.getFamilyMembers()
              
              wx.hideLoading()
              wx.showToast({
                title: '登录成功',
                icon: 'success'
              })
            } catch (error) {
              wx.hideLoading()
              console.error('保存用户信息失败', error)
              wx.showToast({
                title: '登录失败: ' + error.errMsg,
                icon: 'none'
              })
            }
          },
          fail: (err) => {
            wx.hideLoading()
            console.error('云函数调用失败', err)
            wx.showToast({
              title: '登录失败',
              icon: 'none'
            })
          }
        })
      },
      fail: (err) => {
        console.error('获取用户信息失败', err)
        wx.showToast({
          title: '您取消了登录',
          icon: 'none'
        })
      }
    })
  },

  // 退出登录
  logout: function() {
    wx.showModal({
      title: '提示',
      content: '确定要退出登录吗？',
      success: (res) => {
        if (res.confirm) {
          // 清除登录状态
          app.globalData.userInfo = null
          app.globalData.logged = false
          wx.removeStorageSync('userInfo')
          
          this.setData({
            isLoggedIn: false,
            userInfo: null,
            familyMembers: []
          })
          
          wx.showToast({
            title: '已退出登录',
            icon: 'success'
          })
        }
      }
    })
  },

  // 添加新成员
  addNewMember: function() {
    const newMembers = this.data.newMembers.concat({
      name: '',
      age: '',
      height: '',
      weight: '',
      avoid: '',
      favor: ''
    });
    this.setData({
      newMembers
    });
  },

  // 移除新成员
  removeNewMember: function(e) {
    const index = e.currentTarget.dataset.index;
    const newMembers = this.data.newMembers.filter((_, i) => i !== index);
    this.setData({
      newMembers
    });
  },

  // 编辑现有成员
  editMember: function(e) {
    const id = e.currentTarget.dataset.id;
    // 实现编辑功能，可以弹出编辑框或跳转到编辑页面
    wx.showToast({
      title: '编辑功能开发中',
      icon: 'none'
    });
  },

  // 新成员名称变更
  onNewMemberNameChange: function(e) {
    const index = e.currentTarget.dataset.index;
    const value = e.detail.value;
    const newMembers = [...this.data.newMembers];
    newMembers[index].name = value;
    this.setData({
      newMembers
    });
  },

  // 新成员其他字段变更
  onNewMemberFieldChange: function(e) {
    const { index, field } = e.currentTarget.dataset;
    const value = e.detail.value;
    const newMembers = [...this.data.newMembers];
    newMembers[index][field] = value;
    this.setData({
      newMembers
    });
  },

  // 保存新成员
  saveNewMembers: async function() {
    if (this.data.newMembers.length === 0) {
      return;
    }
    
    // 检查新成员信息是否完整
    const incompleteMembers = this.data.newMembers.filter(member => 
      !member.name || !member.age || !member.height || !member.weight
    );
    
    if (incompleteMembers.length > 0) {
      wx.showToast({
        title: '请完善成员信息',
        icon: 'none'
      });
      return;
    }
    
    wx.showLoading({
      title: '保存中...',
      mask: true
    });
    
    try {
      const db = wx.cloud.database()
      
      // 批量添加新成员
      for (const member of this.data.newMembers) {
        // 创建一个新对象，确保没有_openid字段
        const memberData = {
          name: member.name,
          age: member.age,
          height: member.height,
          weight: member.weight,
          avoid: member.avoid || '',
          favor: member.favor || '',
          createTime: new Date()
        };
        
        await db.collection('familyMembers').add({
          data: memberData
        })
      }
      
      // 重新获取家庭成员数据
      this.getFamilyMembers()
      
      // 清空新成员列表
      this.setData({
        newMembers: []
      })
      
      wx.hideLoading()
      wx.showToast({
        title: '保存成功',
        icon: 'success'
      })
      
      return Promise.resolve();
    } catch (error) {
      wx.hideLoading()
      console.error('保存成员失败', error)
      wx.showToast({
        title: '保存失败: ' + (error.errMsg || '未知错误'),
        icon: 'none'
      })
      
      return Promise.reject(error);
    }
  },

  // 生成食谱
  generateRecipe: function() {
    // 检查是否有成员信息
    if (this.data.familyMembers.length === 0 && this.data.newMembers.length === 0) {
      wx.showToast({
        title: '请先添加家庭成员',
        icon: 'none'
      });
      return;
    }

    // 先保存新成员（如果有）
    if (this.data.newMembers.length > 0) {
      this.saveNewMembers().then(() => {
        this.callGenerateRecipeFunction();
      });
    } else {
      this.callGenerateRecipeFunction();
    }
  },

  // 调用生成食谱云函数
  callGenerateRecipeFunction: function() {
    // 显示生成中的提示
    wx.showLoading({
      title: '正在准备生成食谱...',
      mask: true
    });

    // 设置超时定时器
    const timeoutTimer = setTimeout(() => {
      wx.hideLoading();
      wx.showModal({
        title: '提示',
        content: '生成食谱需要较长时间，请耐心等待。您可以先返回首页，稍后查看结果。',
        showCancel: false,
        success: (res) => {
          if (res.confirm) {
            // 跳转到首页
            wx.switchTab({
              url: '/pages/home/index'
            });
          }
        }
      });
    }, 15000); // 15秒后提示用户

    // 调用云函数生成食谱
    wx.cloud.callFunction({
      name: 'recipeManager',
      data: {
        action: 'generateRecipe'
      },
      success: res => {
        clearTimeout(timeoutTimer);
        wx.hideLoading();
        
        if (res.result && res.result.success) {
          wx.showToast({
            title: '食谱生成成功',
            icon: 'success'
          });
          
          // 跳转到首页
          wx.switchTab({
            url: '/pages/home/index'
          });
        } else {
          wx.showModal({
            title: '提示',
            content: res.result.message || '生成失败，请稍后重试',
            showCancel: false
          });
        }
      },
      fail: err => {
        clearTimeout(timeoutTimer);
        wx.hideLoading();
        console.error('调用云函数失败', err);
        
        wx.showModal({
          title: '错误',
          content: '生成失败，请稍后重试',
          showCancel: false
        });
      }
    });
  }
}); 